```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>跳表(Skip List) - 高效有序数据结构详解</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        .hero-section {
            background: linear-gradient(135deg, #6e8efb, #a777e3);
        }
        .code-block {
            background-color: #2d2d2d;
            color: #f8f8f2;
            border-radius: 8px;
            padding: 20px;
            font-family: 'Courier New', Courier, monospace;
            position: relative;
        }
        .code-block::before {
            content: '';
            position: absolute;
            top: 0;
            left: 0;
            width: 4px;
            height: 100%;
            background: linear-gradient(to bottom, #ff8a00, #e52e71);
            border-radius: 8px 0 0 8px;
        }
        .section-title {
            position: relative;
            padding-left: 20px;
        }
        .section-title::before {
            content: '';
            position: absolute;
            left: 0;
            top: 50%;
            transform: translateY(-50%);
            width: 6px;
            height: 24px;
            background: linear-gradient(to bottom, #4facfe, #00f2fe);
            border-radius: 3px;
        }
        .visualization {
            background-color: #f8f9fa;
            border-radius: 12px;
            padding: 20px;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        .comparison-table {
            border-collapse: separate;
            border-spacing: 0;
            width: 100%;
            border-radius: 12px;
            overflow: hidden;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        .comparison-table th {
            background-color: #4facfe;
            color: white;
            padding: 12px 16px;
            text-align: left;
        }
        .comparison-table td {
            padding: 12px 16px;
            border-bottom: 1px solid #e2e8f0;
        }
        .comparison-table tr:last-child td {
            border-bottom: none;
        }
        .comparison-table tr:nth-child(even) {
            background-color: #f8f9fa;
        }
        .hover-card:hover {
            transform: translateY(-4px);
            box-shadow: 0 10px 20px rgba(0, 0, 0, 0.1);
        }
        footer {
            background-color: #2d3748;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-section text-white py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold mb-4">跳表(Skip List)</h1>
                    <h2 class="text-xl md:text-2xl font-light mb-6">兼具链表简洁性与平衡树效率的高级数据结构</h2>
                    <p class="text-lg mb-8 opacity-90">跳表通过多级索引结构将查找时间复杂度从O(n)降低到O(log n)，同时保持了链表的插入和删除效率，是现代计算机科学中的重要数据结构。</p>
                    <div class="flex space-x-4">
                        <a href="#what-is-skip-list" class="bg-white text-indigo-600 px-6 py-3 rounded-full font-medium hover:bg-indigo-100 transition duration-300">
                            <i class="fas fa-book mr-2"></i>了解原理
                        </a>
                        <a href="#code-implementation" class="border-2 border-white text-white px-6 py-3 rounded-full font-medium hover:bg-white hover:text-indigo-600 transition duration-300">
                            <i class="fas fa-code mr-2"></i>查看代码
                        </a>
                    </div>
                </div>
                <div class="md:w-1/2">
                    <div class="visualization">
                        <div class="mermaid">
                            flowchart TD
                                A[头节点] --> B[L3:3]
                                A --> C[L2:3]
                                A --> D[L1:3]
                                A --> E[L0:3]
                                B --> F[L3:9]
                                C --> F
                                D --> G[L1:6]
                                G --> F
                                E --> H[L0:1]
                                H --> I[L0:2]
                                I --> G
                                G --> J[L0:7]
                                J --> F
                                F --> K[L3:25]
                                F --> L[L2:25]
                                F --> M[L1:17]
                                J --> M
                                M --> N[L1:19]
                                N --> K
                                K --> O[L3:26]
                                L --> O
                                N --> P[L0:12]
                                P --> Q[L0:17]
                                Q --> R[L0:19]
                                R --> S[L0:21]
                                S --> T[L0:25]
                                T --> U[L0:26]
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-6xl py-12 px-4 md:px-0">
        <!-- What is Skip List Section -->
        <section id="what-is-skip-list" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">跳表的基本概念</h3>
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-lg mb-6">跳表（Skip List）是一种基于链表的数据结构，通过在链表上添加多级索引来加速查找、插入和删除操作，旨在将这些操作的时间复杂度从 O(n) 降低到 O(log n)，接近于二分查找的性能。</p>
                    <p class="mb-6">跳表引入了层级结构，每一层链表都是下一层链表的子集，较高层的链表包含的节点较少，但跨越的范围更大，这样可以在查找时进行更大步长的跳跃，从而减少查找路径。</p>
                    <div class="bg-blue-50 p-6 rounded-lg border-l-4 border-blue-500">
                        <h4 class="font-bold text-blue-800 mb-3 flex items-center">
                            <i class="fas fa-lightbulb mr-2"></i>核心思想
                        </h4>
                        <p>跳表的基本思想是：在普通链表的基础上，为链表节点增加多层索引，形成一系列从上到下的链表，最底层是完整的链表，每一层都是下一层的一个子集，索引层次越高，包含的节点越少，覆盖的范围越大。</p>
                    </div>
                </div>
                <div>
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1729483287504-fe37b6a0-f8ba-4b0d-bcd1-3755874617a6.png" alt="跳表结构示意图" class="w-full h-auto rounded-lg shadow-md">
                    <p class="text-sm text-gray-500 mt-2 text-center">跳表的层级结构示意图</p>
                </div>
            </div>
        </section>

        <!-- Structure Design Section -->
        <section id="structure-design" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">跳表的结构设计</h3>
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">1. 基础链表结构</h4>
                    <p class="mb-4">跳表的底层是一条有序的单链表，即所有节点按键值从小到大排列，每个节点通过指针指向下一个节点。这与传统链表的设计相同，底层链表负责精确的数据查找，保证查询的正确性。</p>
                    <p>然而，单链表的查找效率较低，为了提高效率，跳表引入了多层链表结构。</p>
                </div>
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">2. 分层结构</h4>
                    <p class="mb-1">跳表的关键在于<strong>多级索引链表</strong>的设计，类似于高速公路和普通公路的关系：</p>
                    <ul class="list-disc pl-5 space-y-2">
                        <li><strong>第0层</strong>：基础层，存储所有元素，保证链表的完整性</li>
                        <li><strong>第1层及以上的层</strong>：作为上层链表，跳跃式地跨越若干底层节点</li>
                    </ul>
                </div>
            </div>
            <div class="bg-indigo-50 p-6 rounded-lg mb-8">
                <h4 class="text-xl font-bold mb-4 text-indigo-700 flex items-center">
                    <i class="fas fa-project-diagram mr-2"></i>节点结构
                </h4>
                <div class="grid md:grid-cols-3 gap-6">
                    <div class="bg-white p-4 rounded-lg shadow-sm">
                        <h5 class="font-bold mb-2 text-indigo-600">Key</h5>
                        <p>节点的键值，用于数据的排序和比较</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm">
                        <h5 class="font-bold mb-2 text-indigo-600">Value</h5>
                        <p>节点的存储值，可以是实际数据或者引用</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm">
                        <h5 class="font-bold mb-2 text-indigo-600">Forward Pointers</h5>
                        <p>一个指针数组，指向不同层级的下一个节点</p>
                    </div>
                </div>
            </div>
            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1729483339231-1e2100b5-dace-48ef-92b1-5c149337298a.png" alt="跳表详细结构" class="w-full rounded-lg shadow-md mb-8">
        </section>

        <!-- Random Level Section -->
        <section id="random-level" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">随机层数的生成</h3>
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">1. 层数的分布模型</h4>
                    <p class="mb-4">跳表中的节点层数分布遵循几何分布（Geometric Distribution），这意味着随着层数的增加，节点在每层中出现的概率逐渐减小。</p>
                    <div class="bg-white p-6 rounded-lg shadow-sm mb-6">
                        <p class="font-medium mb-2">典型分布：</p>
                        <ul class="list-disc pl-5 space-y-1">
                            <li>第0层的所有节点都会出现</li>
                            <li>第1层的节点数量大约是第0层的一半</li>
                            <li>第2层的节点数量大约是第1层的一半</li>
                            <li>以此类推...</li>
                        </ul>
                    </div>
                    <p>这种分布特点确保了跳表中的<strong>稀疏性</strong>和<strong>层级均衡性</strong>，从而实现了快速查找。</p>
                </div>
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">2. 生成随机层数的过程</h4>
                    <p class="mb-4">节点层数的生成过程采用随机化算法，每插入一个新节点时，会使用一定的概率机制生成其层数。以常用的 p = 0.5 为例：</p>
                    <div class="code-block mb-6">
                        <pre><code class="language-java">// 生成随机层数的伪代码
int randomLevel() {
    int level = 0;
    while (Math.random() < p && level < MAX_LEVEL) {
        level++;
    }
    return level;
}</code></pre>
                    </div>
                    <div class="bg-yellow-50 p-4 rounded-lg border-l-4 border-yellow-400">
                        <p>这种层数生成机制具有以下特性：</p>
                        <ul class="list-disc pl-5 mt-2 space-y-1">
                            <li>高度层数稀疏</li>
                            <li>期望层数为对数级别</li>
                            <li>避免局部不平衡</li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <!-- Operations Section -->
        <section id="operations" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">跳表的操作</h3>
            <div class="grid md:grid-cols-3 gap-6 mb-12">
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-blue-500 mb-4 text-3xl">
                        <i class="fas fa-search"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">查找操作</h4>
                    <p class="text-gray-600 mb-4">时间复杂度: O(log n)</p>
                    <p>从顶层开始查找，逐层向下，尽量在每一层找到尽可能接近目标值的节点。</p>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-green-500 mb-4 text-3xl">
                        <i class="fas fa-plus-circle"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">插入操作</h4>
                    <p class="text-gray-600 mb-4">时间复杂度: O(log n)</p>
                    <p>随机生成新节点的层级，先在最底层找到插入位置，再在每一层次中插入相应的节点。</p>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-red-500 mb-4 text-3xl">
                        <i class="fas fa-minus-circle"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">删除操作</h4>
                    <p class="text-gray-600 mb-4">时间复杂度: O(log n)</p>
                    <p>查找到目标节点的每一层位置，然后从每一层删除该节点的指针。</p>
                </div>
            </div>

            <h4 class="text-2xl font-bold mb-6 text-indigo-700">操作流程图</h4>
            <div class="visualization">
                <div class="mermaid">
                    flowchart TD
                        subgraph 查找操作
                            A[从最高层开始] --> B{当前节点 < 目标值?}
                            B -->|是| C[向右移动]
                            B -->|否| D[向下移动]
                            D --> E{到达底层?}
                            E -->|是| F[找到或不存在]
                            E -->|否| B
                        end
                        subgraph 插入操作
                            G[查找插入位置] --> H[生成随机层数]
                            H --> I[从底层到高层插入]
                        end
                        subgraph 删除操作
                            J[查找节点位置] --> K[从高层到底层删除]
                        end
                </div>
            </div>
        </section>

        <!-- Time Complexity Section -->
        <section id="time-complexity" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">跳表的时间复杂度分析</h3>
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">时间复杂度比较</h4>
                    <p class="mb-6">跳表通过分层链表结构来优化这些操作的执行效率，减少节点遍历的数量。每一层链表的节点数是下层的约一半，通过这个分层结构，跳表能够实现二分查找的效果。</p>
                    
                    <table class="comparison-table">
                        <thead>
                            <tr>
                                <th>操作</th>
                                <th>时间复杂度</th>
                            </tr>
                        </thead>
                        <tbody>
                            <tr>
                                <td>查找</td>
                                <td>O(log n)</td>
                            </tr>
                            <tr>
                                <td>插入</td>
                                <td>O(log n)</td>
                            </tr>
                            <tr>
                                <td>删除</td>
                                <td>O(log n)</td>
                            </tr>
                            <tr>
                                <td>空间复杂度</td>
                                <td>O(n)</td>
                            </tr>
                        </tbody>
                    </table>
                </div>
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">查找操作分析</h4>
                    <div class="bg-gray-50 p-6 rounded-lg mb-6">
                        <p class="mb-4"><strong>从顶层开始查找：</strong>查找从最顶层开始，逐层向下移动。在每一层中，从当前节点开始，比较目标值与下一个节点的值。</p>
                        <p><strong>缩小范围：</strong>通过跳表的逐层查找机制，每层跳过的节点数量会随着层数递增而增加，这就类似于二分查找，查找范围每次都减少一半。</p>
                    </div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">空间复杂度</h4>
                    <p>跳表的空间复杂度取决于节点的分布和随机生成的层数。每个节点平均会出现在 log n 层链表中，因此跳表的总空间复杂度为 O(n)。</p>
                </div>
            </div>
        </section>

        <!-- Comparison Section -->
        <section id="comparison" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">跳表与其他数据结构的比较</h3>
            <div class="overflow-x-auto">
                <table class="comparison-table">
                    <thead>
                        <tr>
                            <th>数据结构</th>
                            <th>查找</th>
                            <th>插入</th>
                            <th>删除</th>
                            <th>空间复杂度</th>
                            <th>实现复杂度</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>跳表</td>
                            <td>O(log n)</td>
                            <td>O(log n)</td>
                            <td>O(log n)</td>
                            <td>O(n)</td>
                            <td>中等</td>
                        </tr>
                        <tr>
                            <td>平衡二叉搜索树</td>
                            <td>O(log n)</td>
                            <td>O(log n)</td>
                            <td>O(log n)</td>
                            <td>O(n)</td>
                            <td>高</td>
                        </tr>
                        <tr>
                            <td>哈希表</td>
                            <td>O(1)</td>
                            <td>O(1)</td>
                            <td>O(1)</td>
                            <td>O(n)</td>
                            <td>低</td>
                        </tr>
                        <tr>
                            <td>数组</td>
                            <td>O(n)</td>
                            <td>O(n)</td>
                            <td>O(n)</td>
                            <td>O(n)</td>
                            <td>低</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            <div class="grid md:grid-cols-2 gap-8 mt-12">
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">跳表的优势</h4>
                    <ul class="list-disc pl-5 space-y-2">
                        <li>实现相对简单，不需要复杂的旋转或重平衡操作</li>
                        <li>在并发环境下可以相对容易地实现分段锁机制</li>
                        <li>通过随机化的方式实现平衡，具有较好的稳定性</li>
                        <li>支持高效的范围查询</li>
                    </ul>
                </div>
                <div>
                    <h4 class="text-xl font-bold mb-4 text-indigo-700">适用场景</h4>
                    <ul class="list-disc pl-5 space-y-2">
                        <li>数据库索引</li>
                        <li>缓存系统</li>
                        <li>实时数据处理</li>
                        <li>内存中排序数据结构</li>
                        <li>搜索引擎</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Code Implementation Section -->
        <section id="code-implementation" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">代码实现</h3>
            <div class="code-block mb-8">
                <pre><code class="language-java">import java.util.Random;

// 跳表节点
class SkipListNode {
    int value; // 节点的值
    SkipListNode[] forward; // 节点的前向指针数组

    public SkipListNode(int value, int level) {
        this.value = value;
        this.forward = new SkipListNode[level + 1];
    }
}

// 跳表类
class SkipList {
    private static final int MAX_LEVEL = 16; // 最大层数
    private final SkipListNode header; // 跳表的头节点
    private final Random random; // 随机数生成器
    private int level; // 当前跳表的最大层数

    public SkipList() {
        this.header = new SkipListNode(Integer.MIN_VALUE, MAX_LEVEL); // 初始化头节点
        this.random = new Random();
        this.level = 0; // 初始层数
    }

    // 随机生成节点的层数
    private int randomLevel() {
        int level = 0;
        while (level < MAX_LEVEL && random.nextBoolean()) {
            level++;
        }
        return level;
    }

    // 插入节点
    public void insert(int value) {
        SkipListNode[] update = new SkipListNode[MAX_LEVEL + 1]; // 存储更新路径
        SkipListNode current = header;

        // 从高层到低层查找插入位置
        for (int i = level; i >= 0; i--) {
            while (current.forward[i] != null && current.forward[i].value < value) {
                current = current.forward[i];
            }
            update[i] = current; // 记录前驱节点
        }

        // 处理插入
        current = current.forward[0];

        // 如果值已经存在，则不插入
        if (current != null && current.value == value) {
            return;
        }

        // 生成随机层数
        int newLevel = randomLevel();

        // 如果新层数大于当前层数，更新路径
        if (newLevel > level) {
            for (int i = level + 1; i <= newLevel; i++) {
                update[i] = header;
            }
            level = newLevel; // 更新跳表的层数
        }

        // 创建新节点
        SkipListNode newNode = new SkipListNode(value, newLevel);

        // 插入新节点
        for (int i = 0; i <= newLevel; i++) {
            newNode.forward[i] = update[i].forward[i];
            update[i].forward[i] = newNode;
        }
    }

    // 查找节点
    public boolean search(int value) {
        SkipListNode current = header;

        for (int i = level; i >= 0; i--) {
            while (current.forward[i] != null && current.forward[i].value < value) {
                current = current.forward[i];
            }
        }

        current = current.forward[0]; // 移动到最底层

        return current != null && current.value == value; // 找到值则返回true
    }

    // 删除节点
    public void delete(int value) {
        SkipListNode[] update = new SkipListNode[MAX_LEVEL + 1];
        SkipListNode current = header;

        // 从高层到低层查找删除位置
        for (int i = level; i >= 0; i--) {
            while (current.forward[i] != null && current.forward[i].value < value) {
                current = current.forward[i];
            }
            update[i] = current; // 记录前驱节点
        }

        current = current.forward[0]; // 移动到最底层

        // 如果找到值，则进行删除
        if (current != null && current.value == value) {
            for (int i = 0; i <= level; i++) {
                if (update[i].forward[i] != current) {
                    break;
                }
                update[i].forward[i] = current.forward[i]; // 跳过当前节点
            }

            // 更新跳表的最大层数
            while (level > 0 && header.forward[level] == null) {
                level--;
            }
        }
    }

    // 打印跳表
    public void print() {
        System.out.println("Skip List:");
        for (int i = level; i >= 0; i--) {
            SkipListNode node = header.forward[i];
            System.out.print("Level " + i + ": ");
            while (node != null) {
                System.out.print(node.value + " ");
                node = node.forward[i];
            }
            System.out.println();
        }
    }
}

// 测试跳表
public class SkipListExample {
    public static void main(String[] args) {
        SkipList skipList = new SkipList();

        // 插入节点
        skipList.insert(3);
        skipList.insert(6);
        skipList.insert(7);
        skipList.insert(9);
        skipList.insert(12);
        skipList.insert(19);
        skipList.insert(17);
        skipList.insert(26);
        skipList.insert(21);
        skipList.insert(25);

        // 打印跳表
        skipList.print();

        // 查找节点
        System.out.println("Search for 19: " + skipList.search(19)); // true
        System.out.println("Search for 15: " + skipList.search(15)); // false

        // 删除节点
        skipList.delete(19);
        System.out.println("After deleting 19:");
        skipList.print();
    }
}</code></pre>
            </div>
        </section>

        <!-- Applications Section -->
        <section id="applications" class="mb-20">
            <h3 class="section-title text-3xl font-bold mb-8">跳表的应用场景</h3>
            <div class="grid md:grid-cols-2 lg:grid-cols-3 gap-6">
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-purple-500 mb-4 text-3xl">
                        <i class="fas fa-database"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">数据库索引</h4>
                    <p class="text-gray-600">跳表可作为数据库中的索引结构，支持高效的范围查询和点查询。</p>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-teal-500 mb-4 text-3xl">
                        <i class="fas fa-bolt"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">缓存系统</h4>
                    <p class="text-gray-600">跳表可用于实现高效的缓存系统，如LRU缓存。</p>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-orange-500 mb-4 text-3xl">
                        <i class="fas fa-chart-line"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">实时数据处理</h4>
                    <p class="text-gray-600">在需要实时处理和查询大量数据的场景中，跳表能够提供高效的操作性能。</p>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-blue-500 mb-4 text-3xl">
                        <i class="fas fa-sort-amount-up"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">内存中排序数据结构</h4>
                    <p class="text-gray-600">跳表可用作内存中的排序数据结构，支持频繁的插入和删除操作。</p>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-green-500 mb-4 text-3xl">
                        <i class="fas fa-search"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">搜索引擎</h4>
                    <p class="text-gray-600">在搜索引擎中，跳表可以用于管理文档ID与关键词的映射关系。</p>
                </div>
                <div class="bg-white p-6 rounded-lg shadow-md hover-card transition duration-300">
                    <div class="text-red-500 mb-4 text-3xl">
                        <i class="fas fa-gamepad"></i>
                    </div>
                    <h4 class="text-xl font-bold mb-3">游戏开发</h4>
                    <p class="text-gray-600">跳表可用于管理游戏中实体的状态或属性，如玩家的分数、等级等。</p>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="text-white py-12">
        <div class="container mx-auto max-w-6xl px-4 md:px-0">
            <div class="flex flex-col items-center">
                <h3 class="text-2xl font-bold mb-2">技术小馆</h3>
                <p class="mb-6">探索计算机科学的奥秘</p>
                <a href="http://www.yuque.com/jtostring" class="text-blue-300 hover:text-white transition duration-300">
                    <i class="fas fa-external-link-alt mr-2"></i>http://www.yuque.com/jtostring
                </a>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```